home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_100 / 104_01 / c7.c < prev    next >
Text File  |  1980-01-01  |  14KB  |  589 lines
  1.  
  2. #ifndef TRUE    /* see if include needed */
  3. #include <C.DEF>
  4. #endif
  5. heir11(lval,status)
  6. int *lval;
  7. int *status;
  8. {
  9.         int k;
  10.         char *ptr;
  11.         int  lval2[lvalsize];
  12.         k=primary(lval,status);
  13.         ptr=lval[0];
  14.         blanks();
  15.         switch(ch()) {
  16.  
  17.             /* subscript varble  */
  18.             case '[' :
  19.                 gch();  /* eat '[' */
  20.                 switch(ptr[ident]) {
  21.  
  22.                     /* array of elements */
  23.                     case array :
  24.                     *status=FALSE;
  25.                     ++lval[1];
  26.                         if (const_exp(lval2) && ch()==']') {
  27.                             lval[2]=data_size(lval)*
  28.                                 lval2[0];
  29.                             needbrack("]");
  30.                             return NOTLOADED;
  31.                             }
  32.                         else {
  33.                             expression();
  34.                             size_adjust(lval);
  35.                             swap();
  36.                             address(lval,NOTLOADED);
  37.                             add_address();
  38.                             needbrack("]");
  39.                             return ADDRESS;
  40.                             }
  41.  
  42.                     /* pointer to elements */
  43.                     case pointer:
  44.                     *status=FALSE;
  45.                         if (const_exp(lval2) && ch()==']') {
  46.                         immed();
  47.                         outdec(data_size(lval)*
  48.                             lval2[0]);
  49.                         nl();
  50.                         swap();
  51.                         rvalue(lval,2);
  52.                         add_address();
  53.                             }
  54.                         else {
  55.                             expression();
  56.                             size_adjust(lval);
  57.                             swap();
  58.                             rvalue(lval,2);
  59.                             add_address();
  60.                             }
  61.                         needbrack("]");
  62.                     lval[1] += 1;
  63.                         return ADDRESS;
  64.  
  65.                     /* not a vaild ident for subscript */
  66.                     default :
  67.                         suberror(ptr);
  68.                         return LOADED;
  69.                     }
  70.  
  71.             /* a function call */
  72.             case '(' :
  73.             *status=FALSE;
  74.                 gch(); /* eat '(' */
  75.                 callfunction(lval[0]);
  76.                 return LOADED;
  77.  
  78.             /* not a subscripted or function call (not for this level */
  79.             default:
  80.                 return k;
  81.             }
  82.         }
  83.  
  84. primary(lval,status)
  85. int *lval;
  86. int *status;
  87. {
  88.         char *ptr;
  89.         char sname[namesize];
  90.         int  num[1];
  91.         int k;
  92.  
  93.         /* clear lval array for use */
  94.         lval[0]=
  95.         lval[1]=
  96.         lval[2]=0;
  97.  
  98.         if(match("(")) {
  99.             k=heir1(lval,status);
  100.             needbrack(")");
  101.             return k;
  102.             }
  103.  
  104.     *status=FALSE;
  105.         if (symname(sname)) {
  106.             if ((lval[0]=findloc(sname))) return 2;
  107.             if ((lval[0]=ptr=findglb(sname)))
  108.                 if (ptr[ident] != function) return 2;
  109.             if (ch() =='(') {
  110.                 if (!(ptr=findglb(sname)))
  111.                 if (glbptr>=endglb) {
  112.                     error("global symbol table ofverflow");
  113.                     }
  114.                 else {
  115.                     ptr=glbptr;
  116.                     glbptr+=symsiz;
  117.                     strcpy(ptr+name,sname);
  118.                     ptr[ident]=function;
  119.                     ptr[type]=cint;
  120.                     ptr[offset]=
  121.                     ptr[offset1]=
  122.                     ptr[storage]=
  123.                     ptr[indcnt]=0;
  124.                     }
  125.  
  126.                 lval[0]=ptr;
  127.                 return 2;
  128.                 }
  129.             else {
  130.                 undefine(sname);
  131.                 return 0;
  132.                 }
  133.             }
  134.         if (constant(num)) {
  135.             return 0;
  136.             }
  137.         else {
  138.             error("invalid expression");
  139.             junk();
  140.             return 0;
  141.             }
  142.     }
  143.  
  144. /*                            */
  145. /*      written 4/23/81 by Mike Bernson         */
  146. /*                            */
  147. size_adjust(lval)
  148. int *lval;
  149. {
  150.         int size;
  151.         size=data_size(lval);
  152.         if (size == 1) return;
  153.         if (size == 2) {
  154.             doublereg();
  155.             }
  156.         }
  157.  
  158. /*                            */
  159. /*      written 4/23/81 By Mike Bernson         */
  160. /*                            */
  161. data_size(lval)
  162. int *lval;
  163. {
  164.         char *ptr;
  165.         if (!(ptr=lval[0])) return 0;
  166.         switch(ptr[ident]) {
  167.  
  168.             /* array of elements */
  169.             case array :
  170.                 switch(ptr[type]) {
  171.  
  172.                     /* char type */
  173.                     case cchar:
  174.                         return lchar;
  175.  
  176.                     /* int type */
  177.                     case cint :
  178.                         return lint;
  179.                     }
  180.  
  181.             /* pointer to elements */
  182.             case pointer :
  183.                 if (lval[1] < ptr[indcnt] && ptr[indcnt] > 1)
  184.                     return lpoint;
  185.                 else switch(ptr[type]) {
  186.  
  187.                     /* type char */
  188.                     case cchar :
  189.                         return lchar;
  190.  
  191.                     /* type int */
  192.                     case cint:
  193.                         return lint;
  194.  
  195.                     }
  196.         /* just a plain variable */
  197.         case variable :
  198.             return 1;
  199.             }
  200.         }
  201. /*                            */
  202. /*      written 4/23/81 By Mike Bernson         */
  203. /*                            */
  204. address(lval,k)
  205. int *lval;
  206. {
  207.         char *ptr;
  208.         if (!(ptr=lval[0]) || k != NOTLOADED) return;
  209.         switch(ptr[storage]) {
  210.  
  211.             /* global symbol */
  212.             case statik :
  213.                 immed();
  214.                 outstr(ptr+name);
  215.                 if (lval[2]) {
  216.                     outstr("+");
  217.                     outdec(lval[2]);
  218.                     }
  219.                 nl();
  220.                 break;
  221.  
  222.             /* local symbol */
  223.             case stkloc :
  224.             case stkarg :
  225.                 immed();
  226.                 outdec((ptr[offset]+ptr[offset1]*256+lval[2])-sp);
  227.                 nl();
  228.                 ot("dad\tsp");
  229.                 nl();
  230.                 break;
  231.  
  232.             }
  233.         }
  234. /*                        */
  235. /*    date written 6/6/81 by Mike Bernson    */
  236. /*                        */
  237. /*    check to see if static load or store    */
  238. /*                        */
  239. loadstatic(lval,k)
  240. int *lval;
  241. int k;
  242. {
  243.     char *ptr;
  244.  
  245.     ptr=lval[0];
  246.     if (ptr[storage] == statik && k == NOTLOADED) return TRUE;
  247.     else return FALSE;
  248.     }
  249. /*                            */
  250. /*      date written 4/30/81 By Mike Bernson    */
  251. /*                            */
  252. store(lval,k)
  253. int *lval;
  254. int k;
  255. {
  256.         char *ptr;
  257.     ptr=lval[0];
  258.         if (k==0) return;
  259.         switch(ptr[storage]) {
  260.  
  261.             /* local or arg type */
  262.             case stkloc :
  263.             case stkarg :
  264.             switch(ptr[ident]) {
  265.  
  266.                 /* ident =array */
  267.                 case array:
  268.                     if (lval[1] == ptr[indcnt])
  269.                     if (k==ADDRESS) putstk(ptr[type]);
  270.                     else putmem_stack(lval,ptr[type]);
  271.                     break;
  272.  
  273.                 /* ident is an pointer */
  274.                 case pointer:
  275.                     if (lval[1] == ptr[indcnt])
  276.                     if (k==ADDRESS) putstk(ptr[type]);
  277.                     else putmem_stack(lval,ptr[type]);
  278.                     else    if (k==ADDRESS) putstk(cint);
  279.                     else putmem_stack(lval,cint);
  280.                     break;
  281.  
  282.                 /* ident is a variable */
  283.                 case variable :
  284.                     if (k==ADDRESS) putstk(ptr[type]);
  285.                 else putmem_stack(lval,ptr[type]);
  286.                     break;
  287.                 }
  288.                 break;
  289.  
  290.             /* static varbles */
  291.             case statik :
  292.                 switch(ptr[ident]) {
  293.  
  294.                 /* array */
  295.                 case array :
  296.                     if (lval[1] == ptr[indcnt])
  297.                         if (k==1) putstk(ptr[type]);
  298.                         else putmem(ptr+name,ptr[type],
  299.                             lval[2]);
  300.                     break;
  301.  
  302.                 /* pointer */
  303.                 case pointer:
  304.                     if (lval[1] == ptr[indcnt])
  305.                         if (k==1) putstk(ptr[type]);
  306.                         else putmem(ptr+name,ptr[type],lval[1]);
  307.                     else
  308.                         if (k==1) putstk(cint);
  309.                         else putmem(ptr+name,cint,0);
  310.                     break;
  311.  
  312.                 /* variable */
  313.                 case variable :
  314.                     if (k==1) putstk(ptr[type]);
  315.                     else putmem(ptr+name,ptr[type],0);
  316.                     break;
  317.                 }
  318.             }
  319.         }
  320. /*                            */
  321. /*      written 4/24/81 By Mike Bernson         */
  322. /*                            */
  323. rvalue(lval,k)
  324. int *lval;
  325. int k;
  326. {
  327.         char *ptr;
  328.         ptr=lval[0];
  329.         if (k==0) return;
  330.         switch(ptr[storage]) {
  331.  
  332.             /* local or arg type */
  333.             case stkloc :
  334.             case stkarg :
  335.             switch(ptr[ident]) {
  336.  
  337.                 /* ident =array */
  338.                 case array:
  339.                     if (lval[1] == ptr[indcnt])
  340.                     if (k==ADDRESS) indirect(ptr[type]);
  341.                     else getmem_stack(lval,ptr[type]);
  342.                 else     address(lval,k);
  343.                     break;
  344.  
  345.                 /* ident is an pointer */
  346.                 case pointer:
  347.                     if (lval[1] == ptr[indcnt])
  348.                     if (k==ADDRESS) indirect(ptr[type]);
  349.                     else getmem_stack(lval,ptr[type]);
  350.                     else    if (k==ADDRESS) indirect(cint);
  351.                     else getmem_stack(lval,cint);
  352.                     break;
  353.  
  354.